home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 23 / AACD 23.iso / AACD / Programming / tek / examples / array.c next >
C/C++ Source or Header  |  2001-05-18  |  3KB  |  138 lines
  1.  
  2. /*
  3. **    tek/examples/array.c
  4. **
  5. **    demonstrates brute dynamic array resizing.
  6. **
  7. **    in this example, we put a dynamic array on top of a reallocatable
  8. **    pooled memory manager, with a prefetch ratio of 2:1. this allows
  9. **    rapidly fast array resizing - independent from the underlying kernel's
  10. **    realloc() efficiency.
  11. */
  12.  
  13. #include <stdio.h>
  14. #include <stdlib.h>
  15.  
  16. #include <tek/exec.h>
  17. #include <tek/array.h>
  18.  
  19.  
  20. #define    NUM 2000000
  21. #define DYNAMICGROWTH TTRUE
  22.  
  23.  
  24. int main(int argc, char **argv)
  25. {
  26.     TAPTR task = TCreateTask(TNULL, TNULL, TNULL);
  27.     if (task)
  28.     {
  29.         TMMU mmu;
  30.         TAPTR pool = TCreatePool(TNULL, 256, 128, TNULL);        /* initial prefetch ratio = chunksize/threshold = 2 */
  31.         if (pool)
  32.         {
  33.             if (TInitMMU(&mmu, pool, TMMUT_Pooled, TNULL))
  34.             {
  35.                 TUINT *array = TCreateArray(&mmu, sizeof(TUINT), 0, TNULL);
  36.                 if (array)
  37.                 {
  38.                     TINT i;
  39.                     TTIME t1,t2,t3,t4;
  40.                     TBOOL success = TFALSE;    
  41.     
  42.                     printf("running %d array growth iterations...\n", NUM); fflush(NULL);
  43.     
  44.                     TTimeQuery(task, &t1);
  45.         
  46.                     for (i = 0; i < NUM; ++i)
  47.                     {
  48.                         if (TArraySetLen((TAPTR) &array, i + 1))
  49.                         {
  50.                             array[i] = i;
  51.                         }
  52.                     }    
  53.         
  54.                     TTimeQuery(task, &t2);
  55.         
  56.                     printf("done. time elapsed: %.3fs.\n", TTIMETOF(&t2) - TTIMETOF(&t1)); fflush(NULL);
  57.     
  58.         
  59.         
  60.                     if (TArrayValid(array))
  61.                     {
  62.                         TUINT l = TArrayGetLen(array);
  63.                 
  64.                         printf("array found in valid state. checking integrity...\n"); fflush(NULL);
  65.                 
  66.                         if (l == NUM)
  67.                         {
  68.                             for (i = 0; i < NUM; ++i)
  69.                             {
  70.                                 if (array[i] != i)
  71.                                 {
  72.                                     printf("ALERT: array corrupt!\n");
  73.                                     break;
  74.                                 }
  75.                             }
  76.                             if (i == NUM)
  77.                             {
  78.                                 printf("all right!\n");
  79.                                 success = TTRUE;
  80.                             }
  81.                         }
  82.                         else
  83.                         {
  84.                             printf("array has incorrect size!\n");
  85.                         }
  86.                     }
  87.                     else
  88.                     {
  89.                         printf("array found in invalid state!\n");
  90.                     }
  91.         
  92.         
  93.         
  94.         
  95.         
  96.                     if (success)
  97.                     {
  98.                         printf("shrinking array (%d iterations)...\n", NUM); fflush(NULL);
  99.         
  100.         
  101.                         TTimeQuery(task, &t3);
  102.                 
  103.         
  104.                         for (i = NUM; i >= 0; --i)
  105.                         {
  106.                             TArraySetLen((TAPTR) &array, i);
  107.                         }    
  108.         
  109.         
  110.                         TTimeQuery(task, &t4);
  111.         
  112.                 
  113.                         printf("done. time elapsed: %.3fs. checking integrity...\n", TTIMETOF(&t4) - TTIMETOF(&t3)); fflush(NULL);
  114.         
  115.                         if (TArrayValid(array) && TArrayGetLen(array) == 0)
  116.                         {
  117.                             printf("all right!\n");
  118.                         }
  119.                         else
  120.                         {
  121.                             printf("array found in invalid state!\n");
  122.                         }
  123.                     }
  124.                 
  125.         
  126.                     TDestroyArray(array);        
  127.                 }
  128.                 TDestroy(&mmu);
  129.             }
  130.             TDestroy(pool);
  131.         }
  132.         
  133.         TDestroy(task);
  134.     }
  135.  
  136.     return 0;
  137. }
  138.